#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<unordered_map>
#include<unordered_set>
#include<bitset>
#include<algorithm>
using namespace std;
//class Solution
//{
//public:
//    int widthOfBinaryTree(TreeNode* root)
//    {
//        queue<pair<int, TreeNode*>> q;
//        q.push({ 1,root });
//        int n = 1, ret = 1, Min = 0x3f3f3f3f, Max = 0;
//        while (n--)
//        {
//            auto&= q.top();
//
//        }
//
//    }
//};
  struct ListNode {
      int val;
      ListNode *next;
      ListNode() : val(0), next(nullptr) {}
      ListNode(int x) : val(x), next(nullptr) {}
      ListNode(int x, ListNode *next) : val(x), next(next) {}
  };
 
class Solution4
{
public:
    ListNode* mergeList(vector<ListNode*>& lists, int l, int r)
    {
        if (l == r) return lists[l];
        ListNode* left = mergeList(lists, l, (l + r) / 2);
        ListNode* right = mergeList(lists, (l + r) / 2 + 1, r);
        ListNode* head = new ListNode(-1),*tail=head;
        while (left && right)
        {
            if ((left->val) < (right->val))
            {
                tail->next = left;
                left = left->next;
            }
            else
            {
                tail->next = right;
                right = right->next;
            }
            tail = tail->next;
        }
        if (left) tail->next = left;
        if (right) tail->next = right;
        if (l == 0 && r == lists.size()-1)
        {
            int a = 0;
        }
        return head->next;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists)
    {
        int n = lists.size()-1;
        return mergeList(lists, 0, n);
    }
};
//class Solution7 {
//public:
//    vector<int> smallestK(vector<int>& arr, int k)
//    {
//        priority_queue<int> pq;
//        int i = 0;
//        for (;i < k;++i) pq.push(arr[i]);
//        for (;i < arr.size();++i)
//        {
//            if (arr[i] < pq.top())
//            {
//                pq.pop();pq.push(arr[i]);
//            }
//        }
//        vector<int> ret;
//        while (pq.size())
//        {
//            ret.push_back(pq.top());
//            pq.pop();
//        }
//        return ret;
//    }
//};
int main()
{
    /*ListNode n1(5,nullptr);
    ListNode n2(4,&n1);
    ListNode n3(1,&n2);

    ListNode n4(4,nullptr);
    ListNode n5(3,&n4);
    ListNode n6(1,&n5);

    ListNode n7(6,nullptr);
    ListNode n8(2,&n7);
    vector<ListNode*> lists;
    lists.push_back(&n3);
    lists.push_back(&n6);
    lists.push_back(&n8);
    Solution().mergeKLists(lists);*/
    string s = "aaabbacc";
    unique(s.begin(), s.end());
	return 0;
}
//using ll = long long;
//const int N = 1e5 + 9;
//struct Edge
//{
//    bool operator > (const Edge& e)const
//    {
//        return w == e.w ? v > e.v : w > e.w;
//    }
//    int v;
//    ll w;
//};
//vector<Edge> g[N];
//bool X[N], Y[N];
//void solution()
//{
//    int n, m;cin >> n >> m;
//    for (int i = 1;i <= n;++i) X[i] = true;
//    priority_queue<Edge,vector<Edge>,greater<Edge>> pq;
//    while (m--)
//    {
//        int u, v;ll w;cin >> u >> v >> w;
//        if (u != v)
//        {
//            g[u].push_back({ v,w });
//            g[v].push_back({ u,w });
//        }
//    }
//    for (int i = 1;i <= n;++i)
//        if (g[i].size() > 1)
//        {
//            for (auto e : g[i]) pq.push(e);
//            X[i] = false, Y[i] = true;
//            break;
//        }
//    ll ret = 0;
//    while (pq.size())
//    {
//        auto e = pq.top();pq.pop();
//        int v = e.v;ll w = e.w;
//        if (Y[v]) continue;
//        X[v] = false, Y[v] = true;
//        ret += w;
//        for (auto e : g[v]) pq.push(e);
//    }
//    cout << ret;
//}
//int main()
//{
//    int T = 1;
//    while (T--) solution();
//    return 0;
//}
////using namespace std;
////using ll = long long;
//#define INF  0x3f3f3f3f
//const int N = 2e5 + 5;
//int n, m;
//vector<ll> d(N, 0x3f3f3f3f3f3f);
//struct Edge
//{
//    int v;ll w;
//    bool operator < ( const Edge& e2) const
//    {
//        return w == e2.w ? v > e2.v :w > e2.w;
//    }
//};
//
//vector<Edge> g[N];
//void dijkstra(int x)
//{
//    d[x] = 0;
//    bool vis[N] = { false };
//    priority_queue<Edge> q;
//    for (int i = 1;i <= n;i++) q.push({i,d[i]});
//    for (int i = 1;i <= n;++i)
//    {
//        auto p = q.top();q.pop();
//        while (vis[p.v]) { p = q.top();q.pop(); }
//        vis[p.v] = true;
//            for (auto e : g[p.v])
//            {
//                int v = e.v;ll w = e.w;
//                if (!vis[v] && d[v] > d[p.v] + w)
//                {
//                    d[v] = d[p.v] + w;
//                    q.push({ v, d[v] });
//                }
//            }
//    }
//}
//void solution()
//{
//    cin >> n >> m;
//    vector<int> v;
//    while (m--)
//    {
//        int u, v, w;cin >> u >> v >> w;
//        if (u != v) g[u].push_back({ v,w });
//    }
//    dijkstra(1);
//    cout << d[n];
//}
//
//int main()
//{
//    int T = 1;
//    while (T--) solution();
//    return 0;
//}
//using namespace std;
//using ll = long long;
//const int N = 1e3 + 5;
//int n, m;
//vector<ll> d(N,0x3f3f3f3f3f3f);
//struct Edge
//{
//    int v, w;
//};
//vector<Edge> g[N];
//void dijkstra(int x)
//{
//    d[x] = 0;
//    bool vis[N] = { false };
//    for (int i = 1;i <= n ;++i)
//    {
//        int p = 1;
//        for (int i = 1;i <= n;++i)
//            if (vis[p] || (!vis[i] && d[i] < d[p])) p = i;
//        vis[p] = true;
//        for (auto e : g[p])
//        {
//            int v = e.v, w = e.w;
//            if (!vis[v] && d[v] > d[p] + w) d[v] = d[p] + w;
//        }
//    }
//}
//void solution()
//{
//    cin >> n >> m;
//    while (m--)
//    {
//        int u, v, w;cin >> u >> v >> w;
//        if (u != v) g[u].push_back({ v,w });
//    }
//    dijkstra(1);
//    cout << d[n];
//}
//
//int main()
//{
//    int T = 1;
//    while (T--) solution();
//    return 0;
//}
//using namespace std;
//using ll = long long;
//const int N = 2e5 + 5;
//vector<int> parent(N, -1);
//int findpar(int x)
//{
//    while (parent[x] > 0)
//    {
//        x = parent[x];
//    }
//    return x;
//}
//void solution()
//{
//    int n, m;cin >> n >> m;
//    int a, b;
//    while (m--)
//    {
//        cin >> a >> b;
//        int pa = findpar(a), pb = findpar(b);
//        parent[pb] += parent[pa];
//        parent[pa] = pb;
//    }
//    vector<int> num;
//    for (int i = 1;i <= n;++i)
//        if (parent[i] < 0) num.push_back(-parent[i]);
//    sort(num.begin(), num.end());
//    for (auto e : num) cout << e << ' ';
//}
//int main()
//{
//    int T = 1;
//    while (T--) solution();
//    return 0;
//}
//using namespace std;
//class Solution
//{
//public:
//    int longestOnes(vector<int>& nums, int k)
//    {
//        int arr[2] = { 0 };
//        int n = nums.size();
//        int ret = 0, left = 0, right = 0;
//        while (left < n)
//        {
//            while (right < n && arr[0] <= k)
//            {
//                ret = max(ret, right - left + 1);
//                right++;
//                arr[nums[right]]++;
//            }
//            arr[nums[left++]]--;
//        }
//        return ret;
//    }
//};
//int main()
//{
//    vector<int> v = { 1,1,1,0,0,0,1,1,1,1,0 };
//    Solution().longestOnes(v, 2);
//	return 0;
//}
//using ll = long long;
//int arr[1001][1001];
//int imap[1001][1001];
//int dx[] = { 0,0,1,-1 };
//int dy[] = { 1,-1,0,0 };
//bool vis[1001][1001] = { false };
//struct ordin
//{
//    int x, y;
//};
//int n, m;
//int main()
//{
//    cin >> n >> m;
//    for (int i = 1;i <= n;++i)
//        for (int j = 1;j <= m;++j)
//            cin >> arr[i][j];
//    queue<ordin> q;
//    q.push({ 1,1 });
//    while (q.size())
//    {
//        ordin tmp = q.front();q.pop();
//        for (int i = 0;i < 4;++i)
//        {
//            int nx = tmp.x + dx[i], ny = tmp.y + dy[i];
//            if ((nx >= 1 && nx <= n) && (ny >= 1 && ny <= m) && arr[nx][ny] == 0 && vis[nx][ny]==false)
//            {
//                imap[nx][ny] = imap[tmp.x][tmp.y] + 1;
//                q.push({ nx,ny });
//            }
//        }
//    }
//    cout << (imap[n][m] == 0 ? -1 : imap[n][m]);
//    return 0;
//}
////using namespace std;
//using ll = long long;
//const int N = 2e5 + 9;
//ll n, q;
//ll arr[N], t[N], dif[N];
//
//ll lowbit(ll x)
//{
//    return x & (-x);
//}
//void updata(ll x, ll num)
//{
//    if (x == 0) return;
//    for (ll i = x;i <= n;i += lowbit(i)) 
//        t[i] += num;
//}
//ll getsum(ll pos)
//{
//    ll ret = 0;
//    for (ll i = pos;i >= 1;i -= lowbit(i)) ret += t[i];
//    return ret;
//}
//void solution()
//{
//    vector<int> v;
//    lower_bound(v.begin(), v.end(), 0);
//    cin >> n >> q;
//    for (int i = 1;i <= n;++i) cin >> arr[i];
//    for (int i = 1;i <= n;++i) dif[i] = arr[i] - arr[i - 1];
//    for (int i = 1;i <= n;++i) updata(i, dif[i]);
//    int op;
//    while (q--)
//    {
//        cin >> op;
//        if (op == 1)
//        {
//            ll l, r, num;cin >> l >> r >> num;
//            updata(l, num);updata(r- 1, -num);
//        }
//        else
//        {
//            ll l, r, res = 0;cin >> l >> r;
//            for (ll i = l;i <= r;++i) res += getsum(i);
//            cout << res << '\n';
//        }
//    }
//}
//int main()
//{
//    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
//    int T = 1;
//    while (T--) solution();
//    return 0;
//}